home *** CD-ROM | disk | FTP | other *** search
/ Aminet 41 / Aminet 41 (2001)(Schatztruhe)[!][Feb 2001].iso / Aminet / comm / misc / MPackMUI.lha / MPackMUI / Source / Hooks.C < prev    next >
Encoding:
C/C++ Source or Header  |  2000-08-23  |  48.7 KB  |  1,874 lines
  1. // --------------------------------------------------------------------------------------------------------------
  2. //
  3. //   MPackMUI V1.01 Hooks Module
  4. //
  5. // --------------------------------------------------------------------------------------------------------------
  6.  
  7. #include "Hooks.h"
  8.  
  9. // --------------------------------------------------------------------------------------------------------------
  10.  
  11. __saveds LONG MenuAboutFunc(register __a0 struct Hook *hook, register __a2 APTR obj, register __a1 APTR param)
  12. {
  13.     // Main Window: Project/About
  14.  
  15.     // Display About requester
  16.  
  17.     MUI_Request(App, Windows[WID_MAIN], 0, "About...", "_Ok", "\33c\33bMPackMUI V1.01\33n\n\nA MUI Interface for MPack V1.5\n\nToneMaster, 2000\n<tone_20@my-Deja.com>");
  18.  
  19.     return(0);
  20. } /* MenuAboutFunc() */
  21.  
  22. // --------------------------------------------------------------------------------------------------------------
  23.  
  24. __saveds LONG MenuMIMEPrefsFunc(register __a0 struct Hook *hook, register __a2 APTR obj, register __a1 APTR param)
  25. {
  26.     // Main Window: Preferences/MIME Prefs...
  27.  
  28.     // Open MIME prefs window
  29.  
  30.     set(Windows[WID_MIMEPREFS], MUIA_Window_Open, TRUE);
  31.  
  32.     // Activate the first entry in the MIME list
  33.  
  34.     set(Gadgets[GID_MIMETYPES_LIST_PREFS], MUIA_List_Active, MUIV_List_Active_Top);
  35.  
  36.     // Send main window to sleep whilst MIME prefs window is open
  37.  
  38.     set(Windows[WID_MAIN], MUIA_Window_Sleep, TRUE);
  39.  
  40.     return(0);
  41. } /* MenuPrefsFunc() */
  42.  
  43. // --------------------------------------------------------------------------------------------------------------
  44.  
  45. __saveds LONG MenuResetPrefsFunc(register __a0 struct Hook *hook, register __a2 APTR obj, register __a1 APTR param)
  46. {
  47.     struct Node *tempnode;
  48.     UWORD loop;
  49.  
  50.     // MIME Prefs Window: Edit/Reset to Defaults...
  51.  
  52.     // Send list to sleep
  53.  
  54.     set(Gadgets[GID_MIMETYPES_LIST_PREFS], MUIA_List_Quiet, TRUE);
  55.  
  56.     // Clear list
  57.  
  58.     DoMethod(Gadgets[GID_MIMETYPES_LIST_PREFS], MUIM_List_Clear);
  59.  
  60.     // Free old linked list
  61.  
  62.     FreeList(&MIMEList);
  63.  
  64.     // Build new linked list
  65.  
  66.     NewList(&MIMEList);
  67.  
  68.     loop = 0;
  69.  
  70.     while (DefaultMIMETypes[loop])
  71.     {
  72.         // Allocate node and name
  73.  
  74.         if (!(tempnode = AllocMem(sizeof(struct Node), 0)))
  75.         {
  76.             DoEasyReq("Couldn't allocate node");
  77.             CleanUp();
  78.         } /* if */
  79.  
  80.         if (!(tempnode->ln_Name = AllocMem(256, 0)))
  81.         {
  82.             DoEasyReq("Couldn't allocate node name");
  83.             CleanUp();
  84.         } /* if */
  85.  
  86.         // Copy name from array
  87.  
  88.         strcpy(tempnode->ln_Name, DefaultMIMETypes[loop]);
  89.  
  90.         // Add node to list
  91.  
  92.         AddTail(&MIMEList, tempnode);
  93.  
  94.         loop++;
  95.     } /* while */
  96.  
  97.     // Update MIME Prefs list gadget
  98.  
  99.     if (!(IsListEmpty(&MIMEList)))
  100.     {
  101.         tempnode = MIMEList.lh_Head;
  102.  
  103.         while (tempnode->ln_Succ)
  104.         {
  105.             DoMethod(Gadgets[GID_MIMETYPES_LIST_PREFS], MUIM_List_InsertSingle, tempnode->ln_Name);
  106.  
  107.             tempnode = tempnode->ln_Succ;
  108.         } /* while */
  109.     } /* if */
  110.  
  111.     set(Gadgets[GID_MIMETYPES_LIST_PREFS], MUIA_List_Active, MUIV_List_Active_Top);
  112.  
  113.     // Wake MIME list gadget up
  114.  
  115.     set(Gadgets[GID_MIMETYPES_LIST_PREFS], MUIA_List_Quiet, FALSE);
  116.  
  117.     return(0);
  118. } /* MenuResetPrefsFunc() */
  119.  
  120. // --------------------------------------------------------------------------------------------------------------
  121.  
  122. __saveds LONG MenuLastSavedPrefsFunc(register __a0 struct Hook *hook, register __a2 APTR obj, register __a1 APTR param)
  123. {
  124.     BPTR prefsfile;
  125.     char buffer[256];
  126.     struct Node *tempnode;
  127.  
  128.     // MIME Prefs Window: Edit/Last Saved
  129.  
  130.     // Open the prefs file "ENVARC:MPackMUI.prefs" and load in the MIME list
  131.  
  132.     // Attempt to open the file
  133.  
  134.     if (!(prefsfile = Open("ENVARC:MPackMUI.prefs", MODE_OLDFILE)))
  135.     {
  136.         // No prefs file
  137.  
  138.         DoEasyReq("Couldn't find prefs");
  139.  
  140.         return(0);
  141.     } /* if */
  142.  
  143.     // Send MIME list gadget to sleep
  144.  
  145.     set(Gadgets[GID_MIMETYPES_LIST_PREFS], MUIA_List_Quiet, TRUE);
  146.  
  147.     // Clear the list
  148.  
  149.     DoMethod(Gadgets[GID_MIMETYPES_LIST_PREFS], MUIM_List_Clear);
  150.  
  151.     // Free old linked list
  152.  
  153.     FreeList(&MIMEList);
  154.  
  155.     // Build new linked list
  156.  
  157.     NewList(&MIMEList);
  158.  
  159.     // Get each line of the file in turn
  160.  
  161.     while (FGets(prefsfile, buffer, 256))
  162.     {
  163.         // Allocate node and name
  164.  
  165.         if (!(tempnode = AllocMem(sizeof(struct Node), 0)))
  166.         {
  167.             DoEasyReq("Couldn't allocate node");
  168.             CleanUp();
  169.         } /* if */
  170.  
  171.         if (!(tempnode->ln_Name = AllocMem(256, 0)))
  172.         {
  173.             DoEasyReq("Couldn't allocate label");
  174.             CleanUp();
  175.         } /* if */
  176.  
  177.         // Remove newline
  178.  
  179.         buffer[strlen(buffer) - 1] = '\0';
  180.  
  181.         // Copy name to the node
  182.  
  183.         strcpy(tempnode->ln_Name, buffer);
  184.  
  185.         // Add node to list
  186.  
  187.         AddTail(&MIMEList, tempnode);
  188.     } /* while */
  189.  
  190.     // Close the file
  191.  
  192.     Close(prefsfile);
  193.  
  194.     // Update MIME list gadget
  195.  
  196.     if (!(IsListEmpty(&MIMEList)))
  197.     {
  198.         tempnode = MIMEList.lh_Head;
  199.  
  200.         while (tempnode->ln_Succ)
  201.         {
  202.             DoMethod(Gadgets[GID_MIMETYPES_LIST_PREFS], MUIM_List_InsertSingle, tempnode->ln_Name);
  203.  
  204.             tempnode = tempnode->ln_Succ;
  205.         } /* while */
  206.     } /* if */
  207.  
  208.     // Activate the first entry in the list gadget
  209.  
  210.     set(Gadgets[GID_MIMETYPES_LIST_PREFS], MUIA_List_Active, MUIV_List_Active_Top);
  211.  
  212.     // Wake MIME list gadget up
  213.  
  214.     set(Gadgets[GID_MIMETYPES_LIST_PREFS], MUIA_List_Quiet, FALSE);
  215.  
  216.     return(0);
  217. } /* MenuLastSavedFunc() */
  218.  
  219. // --------------------------------------------------------------------------------------------------------------
  220.  
  221. __saveds LONG MenuRestorePrefsFunc(register __a0 struct Hook *hook, register __a2 APTR obj, register __a1 APTR param)
  222. {
  223.     // MIME Prefs Window: Edit/Restore
  224.  
  225.     // Restore the preferences we had before modification
  226.  
  227.     // Send MIME list gadget to sleep
  228.  
  229.     set(Gadgets[GID_MIMETYPES_LIST_PREFS], MUIA_List_Quiet, TRUE);
  230.  
  231.     // Re-enter old labels into list
  232.  
  233.     DoMethod(Gadgets[GID_MIMETYPES_LIST_PREFS], MUIM_List_Clear);
  234.     DoMethod(Gadgets[GID_MIMETYPES_LIST_PREFS], MUIM_List_Insert, MIMETypes, -1, MUIV_List_Insert_Bottom);
  235.  
  236.     // Rebuild the MIME types list from the MIME types array
  237.  
  238.     RebuildMIMEList();
  239.  
  240.     // Activate the first entry in the list gadget
  241.  
  242.     set(Gadgets[GID_MIMETYPES_LIST_PREFS], MUIA_List_Active, MUIV_List_Active_Top);
  243.  
  244.     // Wake MIME list gadget up
  245.  
  246.     set(Gadgets[GID_MIMETYPES_LIST_PREFS], MUIA_List_Quiet, FALSE);
  247.  
  248.     return(0);
  249. } /* MenuRestorePrefsFunc() */
  250.  
  251. // --------------------------------------------------------------------------------------------------------------
  252.  
  253. __saveds LONG MenuImportAwebPrefsFunc(register __a0 struct Hook *hook, register __a2 APTR obj, register __a1 APTR param)
  254. {
  255.     BOOL skip;
  256.     BPTR prefsfile;
  257.     char buffer[256], mimepart[256], *error;
  258.     struct Node *tempnode;
  259.     UBYTE loop, loop2;
  260.  
  261.     // MIME Prefs Window: Edit/Import Aweb Prefs...
  262.  
  263.     // Import an AWeb 3 prefs file and extract MIME types
  264.  
  265.     // Ask for prefs file
  266.  
  267.     if (!(DoAslFileReq(buffer, "ENVARC:browser", FALSE)))
  268.     {
  269.         // User cancelled requester
  270.  
  271.         return(0);
  272.     } /* if */
  273.  
  274.     // Attempt to open file
  275.  
  276.     if (!(prefsfile = Open(buffer, MODE_OLDFILE)))
  277.     {
  278.         // Can't open file
  279.  
  280.         DoEasyReq("Can't open prefs file");
  281.  
  282.         return(0);
  283.     } /* if */
  284.  
  285.     // Check if this is a MIME prefs file
  286.     //
  287.     // We get the first line, and check that it reads "** Do not modify this by hand! **"
  288.  
  289.     // Get first line and remove the newline
  290.  
  291.     FGets(prefsfile, buffer, 256);
  292.  
  293.     buffer[strlen(buffer) - 1] = '\0';
  294.  
  295.     // Check line
  296.  
  297.     if (strcmp(buffer, "** Do not modify this file by hand! **") != 0)
  298.     {
  299.         // Wrong file format
  300.  
  301.         DoEasyReq("Not an AWeb 3 MIME prefs file");
  302.  
  303.         Close(prefsfile);
  304.         return(0);
  305.     } /* if */
  306.  
  307.     // Send list gadget to sleep
  308.  
  309.     set(Gadgets[GID_MIMETYPES_LIST_PREFS], MUIA_List_Quiet, TRUE);
  310.  
  311.     // Clear list gadget
  312.  
  313.     DoMethod(Gadgets[GID_MIMETYPES_LIST_PREFS], MUIM_List_Clear);
  314.  
  315.     // Free the old linked list
  316.  
  317.     FreeList(&MIMEList);
  318.  
  319.     // Build new linked list
  320.  
  321.     NewList(&MIMEList);
  322.  
  323.     // Search for first MIME descriptor line (begins MIMD)
  324.  
  325.     error = FGets(prefsfile, buffer, 256);
  326.  
  327.     while (buffer[0] != 'M' && buffer[1] != 'I' && error != NULL)
  328.     {
  329.         error = FGets(prefsfile, buffer, 256);
  330.     } /* while */
  331.  
  332.     // Start getting data from file
  333.  
  334.     while (error != NULL)
  335.     {
  336.         // Allocate a new node
  337.  
  338.         if (!(tempnode = AllocMem(sizeof(struct Node), 0)))
  339.         {
  340.             // No memory available
  341.  
  342.             Printf("Out of memory\n");
  343.  
  344.             CleanUp();
  345.         } /* if */
  346.  
  347.         if (!(tempnode->ln_Name = AllocMem(256, 0)))
  348.         {
  349.             // No memory available
  350.  
  351.             Printf("Out of memory\n");
  352.  
  353.             CleanUp();
  354.         } /* if */
  355.  
  356.         // Get first part of MIME type
  357.  
  358.         skip = FALSE;
  359.  
  360.         switch (buffer[5])
  361.         {
  362.             case 'a':
  363.             case 'A':
  364.  
  365.                 if ((buffer[1] == 'p') || (buffer[1] == 'P'))
  366.                 {
  367.                     // Application/
  368.  
  369.                     strcpy(tempnode->ln_Name, "application/");
  370.                 } /* if */
  371.  
  372.                 else
  373.                 {
  374.                     // Audio/
  375.  
  376.                     strcpy(tempnode->ln_Name, "audio/");
  377.                 } /* else */
  378.  
  379.                 break;
  380.  
  381.             case 'i':
  382.             case 'I':
  383.  
  384.                 // Image/
  385.  
  386.                 strcpy(tempnode->ln_Name, "image/");
  387.  
  388.                 break;
  389.  
  390.             case 'v':
  391.             case 'V':
  392.  
  393.                 // Video/
  394.  
  395.                 strcpy(tempnode->ln_Name, "video/");
  396.  
  397.                 break;
  398.  
  399.             default:
  400.  
  401.                 // Unknown type. Free current node and skip to next line
  402.  
  403.                 skip = TRUE;
  404.         } /* switch */
  405.  
  406.         // Check if we have a valid type
  407.  
  408.         if (skip)
  409.         {
  410.             // Bad MIME type (probably text/ or message/)
  411.  
  412.             // Free current node
  413.  
  414.             FreeMem(tempnode->ln_Name, 256);
  415.             FreeMem(tempnode, sizeof(struct Node));
  416.  
  417.             // Reset skip condition
  418.  
  419.             skip = FALSE;
  420.         } /* if */
  421.  
  422.         else
  423.         {
  424.             // Get second part of MIME type
  425.  
  426.             // Search forwards to character after the '/'
  427.  
  428.             loop = 5;
  429.  
  430.             while (buffer[loop] != '/')
  431.             {
  432.                 loop++;
  433.             } /* while */
  434.  
  435.             loop++;
  436.  
  437.             // Search forwards to ';' whilst extracting second part of MIME type
  438.  
  439.             loop2 = 0;
  440.  
  441.             while (buffer[loop] != ';')
  442.             {
  443.                 mimepart[loop2] = tolower(buffer[loop]);
  444.  
  445.                 loop++;
  446.                 loop2++;
  447.             } /* while */
  448.  
  449.             // Terminate string
  450.  
  451.             mimepart[loop2] = '\0';
  452.  
  453.             // Check if we have a valid type
  454.  
  455.             if (mimepart[0] == '*')
  456.             {
  457.                 // Bad MIME type (i.e. audio/*, image/* etc.)
  458.  
  459.                 // Free current node
  460.  
  461.                 FreeMem(tempnode->ln_Name, 256);
  462.                 FreeMem(tempnode, sizeof(struct Node));
  463.             } /* if */
  464.  
  465.             else
  466.             {
  467.                 // Add second part to main part
  468.  
  469.                 strcat(tempnode->ln_Name, mimepart);
  470.  
  471.                 // Link node into list
  472.  
  473.                 AddTail(&MIMEList, tempnode);
  474.             } /* else */
  475.         } /* if */
  476.  
  477.         // Get next line of file
  478.  
  479.         error = FGets(prefsfile, buffer, 256);
  480.     } /* while */
  481.  
  482.     // Close prefs file
  483.  
  484.     Close(prefsfile);
  485.  
  486.     // Insert list into list gadget
  487.  
  488.     if (!(IsListEmpty(&MIMEList)))
  489.     {
  490.         tempnode = MIMEList.lh_Head;
  491.  
  492.         while (tempnode->ln_Succ)
  493.         {
  494.             DoMethod(Gadgets[GID_MIMETYPES_LIST_PREFS], MUIM_List_InsertSingle, tempnode->ln_Name);
  495.  
  496.             tempnode = tempnode->ln_Succ;
  497.         } /* while */
  498.     } /* if */
  499.  
  500.     // Set active entry
  501.  
  502.     set(Gadgets[GID_MIMETYPES_LIST_PREFS], MUIA_List_Active, MUIV_List_Active_Top);
  503.  
  504.     // Wake list gadget up
  505.  
  506.     set(Gadgets[GID_MIMETYPES_LIST_PREFS], MUIA_List_Quiet, FALSE);
  507.  
  508.     // All done
  509.  
  510.     return(0);
  511. } /* MenuImportAwebPrefsFunc() */
  512.  
  513. // --------------------------------------------------------------------------------------------------------------
  514.  
  515. __saveds LONG MenuImportVoyagerPrefsFunc(register __a0 struct Hook *hook, register __a2 APTR obj, register __a1 APTR param)
  516. {
  517.     BOOL skip;
  518.     BPTR prefsfile;
  519.     char buffer[256], mimepart[256];
  520.     struct Node *tempnode;
  521.     UBYTE loop, loop2;
  522.  
  523.     // MIME Prefs Window: Edit/Import Voyager Prefs...
  524.  
  525.     // Import a Voyager 3 MIME prefs file and extract MIME types
  526.  
  527.     // Ask for prefs file
  528.  
  529.     if (!(DoAslFileReq(buffer, "ENVARC:MIME.Prefs", FALSE)))
  530.     {
  531.         // User cancelled requester
  532.  
  533.         return(0);
  534.     } /* if */
  535.  
  536.     // Attempt to open file
  537.  
  538.     if (!(prefsfile = Open(buffer, MODE_OLDFILE)))
  539.     {
  540.         // Can't open file
  541.  
  542.         DoEasyReq("Can't open prefs file");
  543.  
  544.         return(0);
  545.     } /* if */
  546.  
  547.     // Check if this is a MIME prefs file
  548.     //
  549.     // We skip the first line, and check that the next line reads "; MIME Preferences"
  550.  
  551.     // Skip first line
  552.  
  553.     FGets(prefsfile, buffer, 256);
  554.  
  555.     // Get next line and remove the newline
  556.  
  557.     FGets(prefsfile, buffer, 256);
  558.  
  559.     buffer[strlen(buffer) - 1] = '\0';
  560.  
  561.     // Check line
  562.  
  563.     if (strcmp(buffer, "; MIME Preferences") != 0)
  564.     {
  565.         // Wrong file format
  566.  
  567.         DoEasyReq("Not a Voyager 3 MIME prefs file");
  568.  
  569.         Close(prefsfile);
  570.         return(0);
  571.     } /* if */
  572.  
  573.     // Send list gadget to sleep
  574.  
  575.     set(Gadgets[GID_MIMETYPES_LIST_PREFS], MUIA_List_Quiet, TRUE);
  576.  
  577.     // Clear list gadget
  578.  
  579.     DoMethod(Gadgets[GID_MIMETYPES_LIST_PREFS], MUIM_List_Clear);
  580.  
  581.     // Free old linked list
  582.  
  583.     FreeList(&MIMEList);
  584.  
  585.     // Build new linked list
  586.  
  587.     NewList(&MIMEList);
  588.  
  589.     // Skip 3 more lines to beginning of data
  590.  
  591.     FGets(prefsfile, buffer, 256);
  592.     FGets(prefsfile, buffer, 256);
  593.     FGets(prefsfile, buffer, 256);
  594.  
  595.     // Now start getting data from file
  596.  
  597.     FGets(prefsfile, buffer, 256);
  598.  
  599.     while (buffer[0] != ';')
  600.     {
  601.         // Allocate a new node
  602.  
  603.         if (!(tempnode = AllocMem(sizeof(struct Node), 0)))
  604.         {
  605.             // No memory available
  606.  
  607.             Printf("Out of memory\n");
  608.  
  609.             CleanUp();
  610.         } /* if */
  611.  
  612.         if (!(tempnode->ln_Name = AllocMem(256, 0)))
  613.         {
  614.             // No memory available
  615.  
  616.             Printf("Out of memory\n");
  617.  
  618.             CleanUp();
  619.         } /* if */
  620.  
  621.         // Get first part of MIME type
  622.  
  623.         skip = FALSE;
  624.  
  625.         switch (buffer[0])
  626.         {
  627.             case 'a':
  628.             case 'A':
  629.  
  630.                 if ((buffer[1] == 'p') || (buffer[1] == 'P'))
  631.                 {
  632.                     // Application/
  633.  
  634.                     strcpy(tempnode->ln_Name, "application/");
  635.                 } /* if */
  636.  
  637.                 else
  638.                 {
  639.                     // Audio/
  640.  
  641.                     strcpy(tempnode->ln_Name, "audio/");
  642.                 } /* else */
  643.  
  644.                 break;
  645.  
  646.             case 'i':
  647.             case 'I':
  648.  
  649.                 // Image/
  650.  
  651.                 strcpy(tempnode->ln_Name, "image/");
  652.  
  653.                 break;
  654.  
  655.             case 'v':
  656.             case 'V':
  657.  
  658.                 // Video/
  659.  
  660.                 strcpy(tempnode->ln_Name, "video/");
  661.  
  662.                 break;
  663.  
  664.             default:
  665.  
  666.                 // Unknown type. Free current node and skip to next line
  667.  
  668.                 skip = TRUE;
  669.         } /* switch */
  670.  
  671.         // Check if we have a valid type
  672.  
  673.         if (skip)
  674.         {
  675.             // Bad MIME type (probably text/ or message/)
  676.  
  677.             // Free current node
  678.  
  679.             FreeMem(tempnode->ln_Name, 256);
  680.             FreeMem(tempnode, sizeof(struct Node));
  681.  
  682.             // Reset skip condition
  683.  
  684.             skip = FALSE;
  685.         } /* if */
  686.  
  687.         else
  688.         {
  689.             // Get second part of MIME type
  690.  
  691.             // Search forwards to character after the '/'
  692.  
  693.             loop = 0;
  694.  
  695.             while (buffer[loop] != '/')
  696.             {
  697.                 loop++;
  698.             } /* while */
  699.  
  700.             loop++;
  701.  
  702.             // Search forwards to ','
  703.  
  704.             loop2 = loop;
  705.  
  706.             while (buffer[loop2] != ',')
  707.             {
  708.                 loop2++;
  709.             } /* while */
  710.  
  711.             // Extract second part of MIME type
  712.  
  713.             strncpy(mimepart, &buffer[loop], loop2 - loop);
  714.  
  715.             mimepart[loop2 - loop] = '\0';
  716.  
  717.             // Check if we have a valid type
  718.  
  719.             if (mimepart[0] == '*')
  720.             {
  721.                 // Bad MIME type (i.e. audio/*, image/* etc.)
  722.  
  723.                 // Free current node
  724.  
  725.                 FreeMem(tempnode->ln_Name, 256);
  726.                 FreeMem(tempnode, sizeof(struct Node));
  727.             } /* if */
  728.  
  729.             else
  730.             {
  731.                 // Add second part to main part
  732.  
  733.                 strcat(tempnode->ln_Name, mimepart);
  734.  
  735.                 // Link node into list
  736.  
  737.                 AddTail(&MIMEList, tempnode);
  738.             } /* else */
  739.         } /* if */
  740.  
  741.         // Get next line of file
  742.  
  743.         FGets(prefsfile, buffer, 256);
  744.     } /* while */
  745.  
  746.     // Close prefs file
  747.  
  748.     Close(prefsfile);
  749.  
  750.     // Insert list into list gadget
  751.  
  752.     if (!(IsListEmpty(&MIMEList)))
  753.     {
  754.         tempnode = MIMEList.lh_Head;
  755.  
  756.         while (tempnode->ln_Succ)
  757.         {
  758.             DoMethod(Gadgets[GID_MIMETYPES_LIST_PREFS], MUIM_List_InsertSingle, tempnode->ln_Name);
  759.  
  760.             tempnode = tempnode->ln_Succ;
  761.         } /* while */
  762.     } /* if */
  763.  
  764.     // Set active entry
  765.  
  766.     set(Gadgets[GID_MIMETYPES_LIST_PREFS], MUIA_List_Active, MUIV_List_Active_Top);
  767.  
  768.     // Wake list gadget up
  769.  
  770.     set(Gadgets[GID_MIMETYPES_LIST_PREFS], MUIA_List_Quiet, FALSE);
  771.  
  772.     // All done
  773.  
  774.     return(0);
  775. } /* MenuImportVoyagerPrefsFunc() */
  776.  
  777. // --------------------------------------------------------------------------------------------------------------
  778.  
  779. __saveds LONG Page1InputPopFunc(register __a0 struct Hook *hook, register __a2 APTR obj, register __a1 APTR param)
  780. {
  781.     char buffer[256];
  782.     LONG *path;
  783.  
  784.     // Main Window: Page 1 / Input File Pop Gadget
  785.  
  786.     // Get input file and store in the Input String
  787.  
  788.     // Send window to sleep
  789.  
  790.     set(Windows[WID_MAIN], MUIA_Window_Sleep, TRUE);
  791.  
  792.     // Get old path
  793.  
  794.     get(Gadgets[GID_INPUT_STRING_P1], MUIA_String_Contents, &path);
  795.  
  796.     // Ask for the file
  797.  
  798.     if (DoAslFileReq(buffer, (char *)path, FALSE))
  799.     {
  800.         // Store path in string
  801.  
  802.         set(Gadgets[GID_INPUT_STRING_P1], MUIA_String_Contents, buffer);
  803.     } /* if */
  804.  
  805.     // Wake window up
  806.  
  807.     set(Windows[WID_MAIN], MUIA_Window_Sleep, FALSE);
  808.  
  809.     return(0);
  810. } /* Page1InputPopFunc() */
  811.  
  812. // --------------------------------------------------------------------------------------------------------------
  813.  
  814. __saveds LONG Page1OutputPopFunc(register __a0 struct Hook *hook, register __a2 APTR obj, register __a1 APTR param)
  815. {
  816.     char buffer[256];
  817.     LONG *path;
  818.  
  819.     // Main Window: Page 1 / Output File Pop Gadget
  820.  
  821.     // Get output file and store in the Output String
  822.  
  823.     // Send window to sleep
  824.  
  825.     set(Windows[WID_MAIN], MUIA_Window_Sleep, TRUE);
  826.  
  827.     // Get old path
  828.  
  829.     get(Gadgets[GID_OUTPUT_STRING_P1], MUIA_String_Contents, &path);
  830.  
  831.     // Ask for the file
  832.  
  833.     if (DoAslFileReq(buffer, (char *)path, TRUE))
  834.     {
  835.         // Store path in string
  836.  
  837.         set(Gadgets[GID_OUTPUT_STRING_P1], MUIA_String_Contents, buffer);
  838.     } /* if */
  839.  
  840.     // Wake window up
  841.  
  842.     set(Windows[WID_MAIN], MUIA_Window_Sleep, FALSE);
  843.  
  844.     return(0);
  845. } /* Page1OutputPopFunc() */
  846.  
  847. // --------------------------------------------------------------------------------------------------------------
  848.  
  849. __saveds LONG Page1DescPopFunc(register __a0 struct Hook *hook, register __a2 APTR obj, register __a1 APTR param)
  850. {
  851.     char buffer[256];
  852.     LONG *path;
  853.  
  854.     // Main Window: Page 1 / Description File Pop Gadget
  855.  
  856.     // Get description file and store in the Description String
  857.  
  858.     // Send window to sleep
  859.  
  860.     set(Windows[WID_MAIN], MUIA_Window_Sleep, TRUE);
  861.  
  862.     // Get old path
  863.  
  864.     get(Gadgets[GID_DESC_STRING_P1], MUIA_String_Contents, &path);
  865.  
  866.     // Ask for the file
  867.  
  868.     if (DoAslFileReq(buffer, (char *)path, FALSE))
  869.     {
  870.         // Store path in string
  871.  
  872.         set(Gadgets[GID_DESC_STRING_P1], MUIA_String_Contents, buffer);
  873.     } /* if */
  874.  
  875.     // Wake window up
  876.  
  877.     set(Windows[WID_MAIN], MUIA_Window_Sleep, FALSE);
  878.  
  879.     return(0);
  880. } /* Page1DescPopFunc() */
  881.  
  882. // --------------------------------------------------------------------------------------------------------------
  883.  
  884. __saveds LONG Page1DescCheckFunc(register __a0 struct Hook *hook, register __a2 APTR obj, register __a1 APTR param)
  885. {
  886.     LONG *state;
  887.  
  888.     // Main Window: Page 1 / Description Check Gadget
  889.  
  890.     // Enable/Disable Description String & Pop
  891.  
  892.     get(Gadgets[GID_DESC_CHECK_P1], MUIA_Selected, &state);
  893.  
  894.     if (state)
  895.     {
  896.         set(Gadgets[GID_DESC_STRING_P1], MUIA_Disabled, FALSE);
  897.         set(Gadgets[GID_DESC_POP_P1], MUIA_Disabled, FALSE);
  898.     } /* if */
  899.  
  900.     else
  901.     {
  902.         set(Gadgets[GID_DESC_STRING_P1], MUIA_Disabled, TRUE);
  903.         set(Gadgets[GID_DESC_POP_P1], MUIA_Disabled, TRUE);
  904.     } /* else */
  905.  
  906.     return(0);
  907. } /* Page1DescCheckFunc() */
  908.  
  909. // --------------------------------------------------------------------------------------------------------------
  910.  
  911. __saveds LONG Page1MaxCheckFunc(register __a0 struct Hook *hook, register __a2 APTR obj, register __a1 APTR param)
  912. {
  913.     LONG *state;
  914.  
  915.     // Main Window: Page 1 / Maximum Size Check Gadget
  916.  
  917.     // Enable/Disable Maximum Size String
  918.  
  919.     get(Gadgets[GID_MAX_CHECK_P1], MUIA_Selected, &state);
  920.  
  921.     if (state)
  922.     {
  923.         set(Gadgets[GID_MAX_STRING_P1], MUIA_Disabled, FALSE);
  924.     } /* if */
  925.  
  926.     else
  927.     {
  928.         set(Gadgets[GID_MAX_STRING_P1], MUIA_Disabled, TRUE);
  929.     } /* else */
  930.  
  931.     return(0);
  932. } /* Page1MaxCheckFunc() */
  933.  
  934. // --------------------------------------------------------------------------------------------------------------
  935.  
  936. __saveds LONG Page1EncodeButtonFunc(register __a0 struct Hook *hook, register __a2 APTR obj, register __a1 APTR param)
  937. {
  938.     // Main Window: Page 1 / Encode Button Gadget
  939.  
  940.     // Call encoding routine
  941.  
  942.     Encode2File();
  943.  
  944.     return(0);
  945. } /* Page1EncodeButtonFunc() */
  946.  
  947. // --------------------------------------------------------------------------------------------------------------
  948.  
  949. __saveds LONG Page2InputPopFunc(register __a0 struct Hook *hook, register __a2 APTR obj, register __a1 APTR param)
  950. {
  951.     char buffer[256];
  952.     LONG *path;
  953.  
  954.     // Main Window: Page 2 / Input File Pop Gadget
  955.  
  956.     // Get input file and store in the Input String
  957.  
  958.     // Send window to sleep
  959.  
  960.     set(Windows[WID_MAIN], MUIA_Window_Sleep, TRUE);
  961.  
  962.     // Get old path
  963.  
  964.     get(Gadgets[GID_INPUT_STRING_P2], MUIA_String_Contents, &path);
  965.  
  966.     // Ask for the file
  967.  
  968.     if (DoAslFileReq(buffer, (char *)path, FALSE))
  969.     {
  970.         // Store path in string
  971.  
  972.         set(Gadgets[GID_INPUT_STRING_P2], MUIA_String_Contents, buffer);
  973.     } /* if */
  974.  
  975.     // Wake window up
  976.  
  977.     set(Windows[WID_MAIN], MUIA_Window_Sleep, FALSE);
  978.  
  979.     return(0);
  980. } /* Page2InputPopFunc() */
  981.  
  982. // --------------------------------------------------------------------------------------------------------------
  983.  
  984. __saveds LONG Page2OutputPopFunc(register __a0 struct Hook *hook, register __a2 APTR obj, register __a1 APTR param)
  985. {
  986.     char buffer[256];
  987.     LONG *path;
  988.  
  989.     // Main Window: Page 2 / Output Directory Pop Gadget
  990.  
  991.     // Get output directory and store in Output String
  992.  
  993.     // Send window to sleep
  994.  
  995.     set(Windows[WID_MAIN], MUIA_Window_Sleep, TRUE);
  996.  
  997.     // Get old path
  998.  
  999.     get(Gadgets[GID_OUTPUT_STRING_P2], MUIA_String_Contents, &path);
  1000.  
  1001.     // Ask for directory
  1002.  
  1003.     if (DoAslDirReq(buffer, (char *)path))
  1004.     {
  1005.         // Store path in string
  1006.  
  1007.         set(Gadgets[GID_OUTPUT_STRING_P2], MUIA_String_Contents, buffer);
  1008.     } /* if */
  1009.  
  1010.     // Wake window up
  1011.  
  1012.     set(Windows[WID_MAIN], MUIA_Window_Sleep, FALSE);
  1013.  
  1014.     return(0);
  1015. } /* Page2OutputPopFunc() */
  1016.  
  1017. // --------------------------------------------------------------------------------------------------------------
  1018.  
  1019. __saveds LONG Page2DecodeButtonFunc(register __a0 struct Hook *hook, register __a2 APTR obj, register __a1 APTR param)
  1020. {
  1021.     // Main Window: Page 2 / Decode Button Gadget
  1022.  
  1023.     // Call decoding routine
  1024.  
  1025.     Decode2File();
  1026.  
  1027.     return(0);
  1028. } /* Page2DecodeButtonFunc() */
  1029.  
  1030. // --------------------------------------------------------------------------------------------------------------
  1031.  
  1032. __saveds LONG Page3InputPopFunc(register __a0 struct Hook *hook, register __a2 APTR obj, register __a1 APTR param)
  1033. {
  1034.     char buffer[256];
  1035.     LONG *path;
  1036.  
  1037.     // Main Window: Page 3 / Input File Pop Gadget
  1038.  
  1039.     // Get input file and store in the Input String
  1040.  
  1041.     // Send window to sleep
  1042.  
  1043.     set(Windows[WID_MAIN], MUIA_Window_Sleep, TRUE);
  1044.  
  1045.     // Get old path
  1046.  
  1047.     get(Gadgets[GID_INPUT_STRING_P3], MUIA_String_Contents, &path);
  1048.  
  1049.     // Ask for the file
  1050.  
  1051.     if (DoAslFileReq(buffer, (char *)path, FALSE))
  1052.     {
  1053.         // Store path in string
  1054.  
  1055.         set(Gadgets[GID_INPUT_STRING_P3], MUIA_String_Contents, buffer);
  1056.     } /* if */
  1057.  
  1058.     // Wake window up
  1059.  
  1060.     set(Windows[WID_MAIN], MUIA_Window_Sleep, FALSE);
  1061.  
  1062.     return(0);
  1063. } /* Page3InputPopFunc() */
  1064.  
  1065. // --------------------------------------------------------------------------------------------------------------
  1066.  
  1067. __saveds LONG Page3DescPopFunc(register __a0 struct Hook *hook, register __a2 APTR obj, register __a1 APTR param)
  1068. {
  1069.     char buffer[256];
  1070.     LONG *path;
  1071.  
  1072.     // Main Window: Page 3 / Description File Pop Gadget
  1073.  
  1074.     // Get description file and store in the Description String
  1075.  
  1076.     // Send window to sleep
  1077.  
  1078.     set(Windows[WID_MAIN], MUIA_Window_Sleep, TRUE);
  1079.  
  1080.     // Get old path
  1081.  
  1082.     get(Gadgets[GID_DESC_STRING_P3], MUIA_String_Contents, &path);
  1083.  
  1084.     // Ask for the file
  1085.  
  1086.     if (DoAslFileReq(buffer, (char *)path, FALSE))
  1087.     {
  1088.         // Store path in string
  1089.  
  1090.         set(Gadgets[GID_DESC_STRING_P3], MUIA_String_Contents, buffer);
  1091.     } /* if */
  1092.  
  1093.     // Wake window up
  1094.  
  1095.     set(Windows[WID_MAIN], MUIA_Window_Sleep, FALSE);
  1096.  
  1097.     return(0);
  1098. } /* Page3DescPopFunc() */
  1099.  
  1100. // --------------------------------------------------------------------------------------------------------------
  1101.  
  1102. __saveds LONG Page3DescCheckFunc(register __a0 struct Hook *hook, register __a2 APTR obj, register __a1 APTR param)
  1103. {
  1104.     LONG *state;
  1105.  
  1106.     // Main Window: Page 3 / Description Check Gadget
  1107.  
  1108.     // Enable/Disable Description String & Pop
  1109.  
  1110.     get(Gadgets[GID_DESC_CHECK_P3], MUIA_Selected, &state);
  1111.  
  1112.     if (state)
  1113.     {
  1114.         set(Gadgets[GID_DESC_STRING_P3], MUIA_Disabled, FALSE);
  1115.         set(Gadgets[GID_DESC_POP_P3], MUIA_Disabled, FALSE);
  1116.     } /* if */
  1117.  
  1118.     else
  1119.     {
  1120.         set(Gadgets[GID_DESC_STRING_P3], MUIA_Disabled, TRUE);
  1121.         set(Gadgets[GID_DESC_POP_P3], MUIA_Disabled, TRUE);
  1122.     } /* else */
  1123.  
  1124.     return(0);
  1125. } /* Page3DescCheckFunc() */
  1126.  
  1127. // --------------------------------------------------------------------------------------------------------------
  1128.  
  1129. __saveds LONG Page3MaxCheckFunc(register __a0 struct Hook *hook, register __a2 APTR obj, register __a1 APTR param)
  1130. {
  1131.     LONG *state;
  1132.  
  1133.     // Main Window: Page 3 / Maximum Size Check Gadget
  1134.  
  1135.     // Enable/Disable Maximum Size String
  1136.  
  1137.     get(Gadgets[GID_MAX_CHECK_P3], MUIA_Selected, &state);
  1138.  
  1139.     if (state)
  1140.     {
  1141.         set(Gadgets[GID_MAX_STRING_P3], MUIA_Disabled, FALSE);
  1142.     } /* if */
  1143.  
  1144.     else
  1145.     {
  1146.         set(Gadgets[GID_MAX_STRING_P3], MUIA_Disabled, TRUE);
  1147.     } /* else */
  1148.  
  1149.     return(0);
  1150. } /* Page3MaxCheckFunc() */
  1151.  
  1152. // --------------------------------------------------------------------------------------------------------------
  1153.  
  1154. __saveds LONG Page3EncodeButtonFunc(register __a0 struct Hook *hook, register __a2 APTR obj, register __a1 APTR param)
  1155. {
  1156.     // Main Window: Page 3 / Encode Button Gadget
  1157.  
  1158.     // Call encoding routine
  1159.  
  1160.     Encode2Mail();
  1161.  
  1162.     return(0);
  1163. } /* Page3EncodeButtonFunc() */
  1164.  
  1165. // --------------------------------------------------------------------------------------------------------------
  1166.  
  1167. __saveds LONG Page4InputPopFunc(register __a0 struct Hook *hook, register __a2 APTR obj, register __a1 APTR param)
  1168. {
  1169.     char buffer[256];
  1170.     LONG *path;
  1171.  
  1172.     // Main Window: Page 4 - Input File Pop Gadget
  1173.  
  1174.     // Get input file and store in the Input String
  1175.  
  1176.     // Send window to sleep
  1177.  
  1178.     set(Windows[WID_MAIN], MUIA_Window_Sleep, TRUE);
  1179.  
  1180.     // Get old path
  1181.  
  1182.     get(Gadgets[GID_INPUT_STRING_P4], MUIA_String_Contents, &path);
  1183.  
  1184.     // Ask for the file
  1185.  
  1186.     if (DoAslFileReq(buffer, (char *)path, FALSE))
  1187.     {
  1188.         // Store path in string
  1189.  
  1190.         set(Gadgets[GID_INPUT_STRING_P4], MUIA_String_Contents, buffer);
  1191.     } /* if */
  1192.  
  1193.     // Wake window up
  1194.  
  1195.     set(Windows[WID_MAIN], MUIA_Window_Sleep, FALSE);
  1196.  
  1197.     return(0);
  1198. } /* Page4InputPopFunc() */
  1199.  
  1200. // --------------------------------------------------------------------------------------------------------------
  1201.  
  1202. __saveds LONG Page4DescPopFunc(register __a0 struct Hook *hook, register __a2 APTR obj, register __a1 APTR param)
  1203. {
  1204.     char buffer[256];
  1205.     LONG *path;
  1206.  
  1207.     // Main Window: Page 4 / Description File Pop Gadget
  1208.  
  1209.     // Get description file and store in the Description String
  1210.  
  1211.     // Send window to sleep
  1212.  
  1213.     set(Windows[WID_MAIN], MUIA_Window_Sleep, TRUE);
  1214.  
  1215.     // Get old path
  1216.  
  1217.     get(Gadgets[GID_DESC_STRING_P4], MUIA_String_Contents, &path);
  1218.  
  1219.     // Ask for the file
  1220.  
  1221.     if (DoAslFileReq(buffer, (char *)path, FALSE))
  1222.     {
  1223.         // Store path in string
  1224.  
  1225.         set(Gadgets[GID_DESC_STRING_P4], MUIA_String_Contents, buffer);
  1226.     } /* if */
  1227.  
  1228.     // Wake window up
  1229.  
  1230.     set(Windows[WID_MAIN], MUIA_Window_Sleep, FALSE);
  1231.  
  1232.     return(0);
  1233. } /* Page4DescPopFunc() */
  1234.  
  1235. // --------------------------------------------------------------------------------------------------------------
  1236.  
  1237. __saveds LONG Page4DescCheckFunc(register __a0 struct Hook *hook, register __a2 APTR obj, register __a1 APTR param)
  1238. {
  1239.     LONG *state;
  1240.  
  1241.     // Main Window: Page 4 / Description Check Gadget
  1242.  
  1243.     // Enable/Disable Description String & Pop
  1244.  
  1245.     get(Gadgets[GID_DESC_CHECK_P4], MUIA_Selected, &state);
  1246.  
  1247.     if (state)
  1248.     {
  1249.         set(Gadgets[GID_DESC_STRING_P4], MUIA_Disabled, FALSE);
  1250.         set(Gadgets[GID_DESC_POP_P4], MUIA_Disabled, FALSE);
  1251.     } /* if */
  1252.  
  1253.     else
  1254.     {
  1255.         set(Gadgets[GID_DESC_STRING_P4], MUIA_Disabled, TRUE);
  1256.         set(Gadgets[GID_DESC_POP_P4], MUIA_Disabled, TRUE);
  1257.     } /* else */
  1258.  
  1259.     return(0);
  1260. } /* Page4DescCheckFunc() */
  1261.  
  1262. // --------------------------------------------------------------------------------------------------------------
  1263.  
  1264. __saveds LONG Page4MaxCheckFunc(register __a0 struct Hook *hook, register __a2 APTR obj, register __a1 APTR param)
  1265. {
  1266.     LONG *state;
  1267.  
  1268.     // Main Window: Page 4 / Maximum Size Check Gadget
  1269.  
  1270.     // Enable/Disable Maximum Size String
  1271.  
  1272.     get(Gadgets[GID_MAX_CHECK_P4], MUIA_Selected, &state);
  1273.  
  1274.     if (state)
  1275.     {
  1276.         set(Gadgets[GID_MAX_STRING_P4], MUIA_Disabled, FALSE);
  1277.     } /* if */
  1278.  
  1279.     else
  1280.     {
  1281.         set(Gadgets[GID_MAX_STRING_P4], MUIA_Disabled, TRUE);
  1282.     } /* else */
  1283.  
  1284.     return(0);
  1285. } /* Page4MaxCheckFunc() */
  1286.  
  1287. // --------------------------------------------------------------------------------------------------------------
  1288.  
  1289. __saveds LONG Page4EncodeButtonFunc(register __a0 struct Hook *hook, register __a2 APTR obj, register __a1 APTR param)
  1290. {
  1291.     // Main Window: Page 4 / Encode Button Gadget
  1292.  
  1293.     // Call encoding routine
  1294.  
  1295.     Encode2NG();
  1296.  
  1297.     return(0);
  1298. } /* Page4EncodeButtonFunc() */
  1299.  
  1300. // --------------------------------------------------------------------------------------------------------------
  1301.  
  1302. __saveds LONG PrefsMIMEListFunc(register __a0 struct Hook *hook, register __a2 APTR obj, register __a1 APTR param)
  1303. {
  1304.     char *entry;
  1305.     UBYTE loop;
  1306.  
  1307.     // MIME Prefs Window: MIME List Gadget
  1308.  
  1309.     // Grab type from list
  1310.  
  1311.     DoMethod(Gadgets[GID_MIMETYPES_LIST_PREFS], MUIM_List_GetEntry, MUIV_List_GetEntry_Active, &entry);
  1312.  
  1313.     if (entry)
  1314.     {
  1315.         // Set cycle gadget part WITHOUT notification (which would call PrefsMIMECycleFunc() )
  1316.  
  1317.         switch (entry[0])
  1318.         {
  1319.             case 'a':
  1320.  
  1321.                 if (entry[1] == 'p')
  1322.                 {
  1323.                     // Application/
  1324.  
  1325.                     nnset(Gadgets[GID_MIMETYPES_CYCLE_PREFS], MUIA_Cycle_Active, 0);
  1326.                 } /* if */
  1327.  
  1328.                 else
  1329.                 {
  1330.                     // Audio/
  1331.  
  1332.                     nnset(Gadgets[GID_MIMETYPES_CYCLE_PREFS], MUIA_Cycle_Active, 1);
  1333.                 } /* else */
  1334.  
  1335.                 break;
  1336.  
  1337.             case 'i':
  1338.  
  1339.                 // Image/
  1340.  
  1341.                 nnset(Gadgets[GID_MIMETYPES_CYCLE_PREFS], MUIA_Cycle_Active, 2);
  1342.  
  1343.                 break;
  1344.  
  1345.             case 'v':
  1346.  
  1347.                 // Video/
  1348.  
  1349.                 nnset(Gadgets[GID_MIMETYPES_CYCLE_PREFS], MUIA_Cycle_Active, 4);
  1350.  
  1351.                 break;
  1352.  
  1353.         } /* select */
  1354.  
  1355.         // Set string part
  1356.  
  1357.         loop = 0;
  1358.  
  1359.         while (entry[loop] != '/')
  1360.         {
  1361.             loop++;
  1362.         } /* if */
  1363.  
  1364.         loop++;
  1365.  
  1366.         set(Gadgets[GID_MIMETYPES_STRING_PREFS], MUIA_String_Contents, &entry[loop]);
  1367.     } /* if */
  1368.  
  1369.     return(0);
  1370. } /* PrefsMIMEListFunc() */
  1371.  
  1372. // --------------------------------------------------------------------------------------------------------------
  1373.  
  1374. __saveds LONG PrefsMIMEUpdateFunc(register __a0 struct Hook *hook, register __a2 APTR obj, register __a1 APTR param)
  1375. {
  1376.     char newentry[256], *stringpart;
  1377.     LONG entrynum;
  1378.     struct Node *tempnode;
  1379.     UWORD loop;
  1380.  
  1381.     // MIME Prefs Window: MIME Cycle / String Gadget
  1382.  
  1383.     // Adjust entry in list
  1384.  
  1385.     get(Gadgets[GID_MIMETYPES_CYCLE_PREFS], MUIA_Cycle_Active, &entrynum);
  1386.  
  1387.     // Get cycle part
  1388.  
  1389.     switch(entrynum)
  1390.     {
  1391.         case 0:
  1392.  
  1393.             strcpy(newentry, "application/");
  1394.  
  1395.             break;
  1396.  
  1397.         case 1:
  1398.  
  1399.             strcpy(newentry, "audio/");
  1400.  
  1401.             break;
  1402.  
  1403.         case 2:
  1404.  
  1405.             strcpy(newentry, "image/");
  1406.  
  1407.             break;
  1408.  
  1409.         case 3:
  1410.  
  1411.             strcpy(newentry, "audio/");
  1412.  
  1413.             break;
  1414.  
  1415.     } /* switch */
  1416.  
  1417.     // Get string part
  1418.  
  1419.     get(Gadgets[GID_MIMETYPES_STRING_PREFS], MUIA_String_Contents, &stringpart);
  1420.  
  1421.     // Build new type
  1422.  
  1423.     strcat(newentry, stringpart);
  1424.  
  1425.     // Send list to sleep
  1426.  
  1427.     set(Gadgets[GID_MIMETYPES_LIST_PREFS], MUIA_List_Quiet, TRUE);
  1428.  
  1429.     // Modify linked list and update list gadget
  1430.  
  1431.     // Find entry in linked list corresponding to currently active entry in list gadget
  1432.  
  1433.     get(Gadgets[GID_MIMETYPES_LIST_PREFS], MUIA_List_Active, &entrynum);
  1434.  
  1435.     if (!(IsListEmpty(&MIMEList)))
  1436.     {
  1437.         tempnode = MIMEList.lh_Head;
  1438.  
  1439.         for (loop = 0; loop < entrynum; loop++)
  1440.         {
  1441.             // Go to next node in linked list
  1442.  
  1443.             tempnode = tempnode->ln_Succ;
  1444.         } /* for */
  1445.     } /* if */
  1446.  
  1447.     // Update linked list
  1448.  
  1449.     strcpy(tempnode->ln_Name, newentry);
  1450.  
  1451.     // Update list gadget
  1452.  
  1453.     DoMethod(Gadgets[GID_MIMETYPES_LIST_PREFS], MUIM_List_InsertSingle, tempnode->ln_Name, entrynum);
  1454.     DoMethod(Gadgets[GID_MIMETYPES_LIST_PREFS], MUIM_List_Remove, MUIV_List_Remove_Active);
  1455.  
  1456.     set(Gadgets[GID_MIMETYPES_LIST_PREFS], MUIA_List_Active, entrynum);
  1457.  
  1458.     // Wake up list
  1459.  
  1460.     set(Gadgets[GID_MIMETYPES_LIST_PREFS], MUIA_List_Quiet, FALSE);
  1461.  
  1462.     return(0);
  1463. } /* PrefsMIMEUpdateFunc() */
  1464.  
  1465. // --------------------------------------------------------------------------------------------------------------
  1466.  
  1467. __saveds LONG PrefsAddButtonFunc(register __a0 struct Hook *hook, register __a2 APTR obj, register __a1 APTR param)
  1468. {
  1469.     struct Node *tempnode;
  1470.  
  1471.     // MIME Prefs Window: Add Button Gadget
  1472.  
  1473.     // Add a new item to the list
  1474.  
  1475.     // First, add a node to the linked list
  1476.  
  1477.     if (!(tempnode = AllocMem(sizeof(struct Node), 0)))
  1478.     {
  1479.         DoEasyReq("Couldn't allocate node");
  1480.         CleanUp();
  1481.     } /* if */
  1482.  
  1483.     if (!(tempnode->ln_Name = AllocMem(256, 0)))
  1484.     {
  1485.         DoEasyReq("Couldn't allocate label");
  1486.         CleanUp();
  1487.     } /* if */
  1488.  
  1489.     strcpy(tempnode->ln_Name, "application/");
  1490.  
  1491.     AddTail(&MIMEList, tempnode);
  1492.  
  1493.     // Now update the list
  1494.  
  1495.     DoMethod(Gadgets[GID_MIMETYPES_LIST_PREFS], MUIM_List_InsertSingle, tempnode->ln_Name, MUIV_List_Insert_Bottom);
  1496.  
  1497.     set(Gadgets[GID_MIMETYPES_LIST_PREFS], MUIA_List_Active, MUIV_List_Active_Bottom);
  1498.  
  1499.     return(0);
  1500. } /* PrefsAddButtonFunc() */
  1501.  
  1502. // --------------------------------------------------------------------------------------------------------------
  1503.  
  1504. __saveds LONG PrefsRemoveButtonFunc(register __a0 struct Hook *hook, register __a2 APTR obj, register __a1 APTR param)
  1505. {
  1506.     LONG entrynum;
  1507.     struct Node *tempnode;
  1508.     UWORD loop;
  1509.  
  1510.     // MIME Prefs Window: Remove Button Gadget
  1511.  
  1512.     // Remove an item from the list
  1513.  
  1514.     // First, find the node in the linked list
  1515.  
  1516.     get(Gadgets[GID_MIMETYPES_LIST_PREFS], MUIA_List_Active, &entrynum);
  1517.  
  1518.     if (entrynum == MUIV_List_Active_Off)
  1519.     {
  1520.         // No entry selected.
  1521.  
  1522.         return(0);
  1523.     } /* if */
  1524.  
  1525.     if (!(IsListEmpty(&MIMEList)))
  1526.     {
  1527.         tempnode = MIMEList.lh_Head;
  1528.  
  1529.         for (loop = 0; loop < entrynum; loop++)
  1530.         {
  1531.             // Go to next node in linked list
  1532.  
  1533.             tempnode = tempnode->ln_Succ;
  1534.         } /* for */
  1535.     } /* if */
  1536.  
  1537.     // Remove the entry from the list gadget
  1538.  
  1539.     DoMethod(Gadgets[GID_MIMETYPES_LIST_PREFS], MUIM_List_Remove, MUIV_List_Remove_Active);
  1540.  
  1541.     // Remove the node from the linked list
  1542.  
  1543.     Remove(tempnode);
  1544.  
  1545.     FreeMem(tempnode->ln_Name, 256);
  1546.     FreeMem(tempnode, sizeof(struct Node));
  1547.  
  1548.     return(0);
  1549. } /* PrefsRemoveButtonFunc() */
  1550.  
  1551. // --------------------------------------------------------------------------------------------------------------
  1552.  
  1553. __saveds LONG PrefsCopyButtonFunc(register __a0 struct Hook *hook, register __a2 APTR obj, register __a1 APTR param)
  1554. {
  1555.     char *entry;
  1556.     LONG entrynum;
  1557.     struct Node *tempnode;
  1558.  
  1559.     // MIME Prefs Window: Copy Button Gadget
  1560.  
  1561.     // Duplicate an entry in the list
  1562.  
  1563.     // Get the active entry from the list
  1564.  
  1565.     get(Gadgets[GID_MIMETYPES_LIST_PREFS], MUIA_List_Active, &entrynum);
  1566.  
  1567.     if (entrynum == MUIV_List_Active_Off)
  1568.     {
  1569.         // No entry selected.
  1570.  
  1571.         return(0);
  1572.     } /* if */
  1573.  
  1574.     DoMethod(Gadgets[GID_MIMETYPES_LIST_PREFS], MUIM_List_GetEntry, entrynum, &entry);
  1575.  
  1576.     // Add a new node to the linked list
  1577.  
  1578.     if (!(tempnode = AllocMem(sizeof(struct Node), 0)))
  1579.     {
  1580.         DoEasyReq("Couldn't allocate node");
  1581.         CleanUp();
  1582.     } /* if */
  1583.  
  1584.     if (!(tempnode->ln_Name = AllocMem(256, 0)))
  1585.     {
  1586.         DoEasyReq("Couldn't allocate label");
  1587.         CleanUp();
  1588.     } /* if */
  1589.  
  1590.     strcpy(tempnode->ln_Name, entry);
  1591.  
  1592.     AddTail(&MIMEList, tempnode);
  1593.  
  1594.     // Add the entry to the list gadget
  1595.  
  1596.     DoMethod(Gadgets[GID_MIMETYPES_LIST_PREFS], MUIM_List_InsertSingle, tempnode->ln_Name, MUIV_List_Insert_Bottom);
  1597.  
  1598.     set(Gadgets[GID_MIMETYPES_LIST_PREFS], MUIA_List_Active, MUIV_List_Active_Bottom);
  1599.  
  1600.     return(0);
  1601. } /* PrefsCopyButtonFunc() */
  1602.  
  1603. // --------------------------------------------------------------------------------------------------------------
  1604.  
  1605. __saveds LONG PrefsSortButtonFunc(register __a0 struct Hook *hook, register __a2 APTR obj, register __a1 APTR param)
  1606. {
  1607.     char *entry;
  1608.     LONG numentries;
  1609.     struct Node *swapnode1, *swapnode2, *sw1pred;
  1610.     UWORD loop;
  1611.  
  1612.     // MIME Prefs Window: Sort Button Gadget
  1613.  
  1614.     // Sort the list
  1615.  
  1616.     DoMethod(Gadgets[GID_MIMETYPES_LIST_PREFS], MUIM_List_Sort);
  1617.  
  1618.     // Sort the linked list
  1619.  
  1620.     get(Gadgets[GID_MIMETYPES_LIST_PREFS], MUIA_List_Entries, &numentries);
  1621.  
  1622.     swapnode1 = MIMEList.lh_Head;
  1623.  
  1624.     for (loop = 0; loop < numentries; loop++)
  1625.     {
  1626.         DoMethod(Gadgets[GID_MIMETYPES_LIST_PREFS], MUIM_List_GetEntry, loop, &entry);
  1627.  
  1628.         if (!(swapnode2 = FindName(&MIMEList, entry)))
  1629.         {
  1630.             // Something went wrong
  1631.  
  1632.             DoEasyReq("?");
  1633.             CleanUp();
  1634.         } /* if */
  1635.  
  1636.         if (swapnode1 != swapnode2)
  1637.         {
  1638.             // Swap nodes
  1639.  
  1640.             sw1pred = swapnode1->ln_Pred;
  1641.  
  1642.             // Remove first node and insert after second node
  1643.  
  1644.             Remove(swapnode1);
  1645.  
  1646.             Insert(&MIMEList, swapnode1, swapnode2);
  1647.  
  1648.             // Remove second node and insert after first node's original position
  1649.  
  1650.             Remove(swapnode2);
  1651.  
  1652.             if (loop == 0)
  1653.             {
  1654.                 // Insert at head of list
  1655.  
  1656.                 AddHead(&MIMEList, swapnode2);
  1657.             } /* if */
  1658.  
  1659.             else
  1660.             {
  1661.                 // Insert after first node's original position
  1662.  
  1663.                 Insert(&MIMEList, swapnode2, sw1pred);
  1664.             } /* else */
  1665.  
  1666.             swapnode1 = swapnode2->ln_Succ;
  1667.         } /* if */
  1668.  
  1669.         else
  1670.         {
  1671.             swapnode1 = swapnode1->ln_Succ;
  1672.         } /* else */
  1673.     } /* for */
  1674.  
  1675.     return(0);
  1676. } /* PrefsSortButtonFunc() */
  1677.  
  1678. // --------------------------------------------------------------------------------------------------------------
  1679.  
  1680. __saveds LONG PrefsSaveButtonFunc(register __a0 struct Hook *hook, register __a2 APTR obj, register __a1 APTR param)
  1681. {
  1682.     // MIME Prefs Window: Save Button Gadget
  1683.  
  1684.     // Save the current preferences
  1685.  
  1686.     // Close the window and rebuild the MIME types list
  1687.  
  1688.     set(Windows[WID_MIMEPREFS], MUIA_Window_Open, FALSE);
  1689.  
  1690.     DoMethod(Gadgets[GID_MIMETYPES_LIST_PREFS], MUIM_List_Clear);
  1691.  
  1692.     RebuildMIMETypes();
  1693.  
  1694.     // Update the MIME Prefs list gadget
  1695.  
  1696.     DoMethod(Gadgets[GID_MIMETYPES_LIST_PREFS], MUIM_List_Insert, MIMETypes, -1, MUIV_List_Insert_Bottom);
  1697.  
  1698.     // Update the cycle gadgets
  1699.  
  1700.     if (DoMethod(Gadgets[GID_TYPE_GROUP_P1], MUIM_Group_InitChange))
  1701.     {
  1702.         DoMethod(Gadgets[GID_TYPE_GROUP_P1], OM_REMMEMBER, Gadgets[GID_TYPE_CYCLE_P1]);
  1703.         MUI_DisposeObject(Gadgets[GID_TYPE_CYCLE_P1]);
  1704.  
  1705.         DoMethod(Gadgets[GID_TYPE_GROUP_P1], OM_ADDMEMBER, Gadgets[GID_TYPE_CYCLE_P1] = CycleObject, MUIA_Cycle_Entries, MIMETypes, End);
  1706.  
  1707.         DoMethod(Gadgets[GID_TYPE_GROUP_P1], MUIM_Group_ExitChange);
  1708.     } /* if */
  1709.  
  1710.     if (DoMethod(Gadgets[GID_TYPE_GROUP_P3], MUIM_Group_InitChange))
  1711.     {
  1712.         DoMethod(Gadgets[GID_TYPE_GROUP_P3], OM_REMMEMBER, Gadgets[GID_TYPE_CYCLE_P3]);
  1713.         MUI_DisposeObject(Gadgets[GID_TYPE_CYCLE_P3]);
  1714.  
  1715.         DoMethod(Gadgets[GID_TYPE_GROUP_P3], OM_ADDMEMBER, Gadgets[GID_TYPE_CYCLE_P3] = CycleObject, MUIA_Cycle_Entries, MIMETypes, End);
  1716.  
  1717.         DoMethod(Gadgets[GID_TYPE_GROUP_P3], MUIM_Group_ExitChange);
  1718.     } /* if */
  1719.  
  1720.     if (DoMethod(Gadgets[GID_TYPE_GROUP_P4], MUIM_Group_InitChange))
  1721.     {
  1722.         DoMethod(Gadgets[GID_TYPE_GROUP_P4], OM_REMMEMBER, Gadgets[GID_TYPE_CYCLE_P4]);
  1723.         MUI_DisposeObject(Gadgets[GID_TYPE_CYCLE_P4]);
  1724.  
  1725.         DoMethod(Gadgets[GID_TYPE_GROUP_P4], OM_ADDMEMBER, Gadgets[GID_TYPE_CYCLE_P4] = CycleObject, MUIA_Cycle_Entries, MIMETypes, End);
  1726.  
  1727.         DoMethod(Gadgets[GID_TYPE_GROUP_P4], MUIM_Group_ExitChange);
  1728.     } /* if */
  1729.  
  1730.     // Save the prefs to ENV:MPackMUI.prefs and ENVARC:MPackMUI.prefs
  1731.  
  1732.     SavePrefs("ENV:MPackMUI.prefs");
  1733.     SavePrefs("ENVARC:MPackMUI.prefs");
  1734.  
  1735.     // Wake up the main window
  1736.  
  1737.     set(Windows[WID_MAIN], MUIA_Window_Sleep, FALSE);
  1738.  
  1739.     return(0);
  1740. } /* PrefsSaveButtonFunc() */
  1741.  
  1742. // --------------------------------------------------------------------------------------------------------------
  1743.  
  1744. __saveds LONG PrefsUseButtonFunc(register __a0 struct Hook *hook, register __a2 APTR obj, register __a1 APTR param)
  1745. {
  1746.     // MIME Prefs Window: Use Button Gadget
  1747.  
  1748.     // Use the current preferences
  1749.  
  1750.     // Close the window and rebuild the MIME types list
  1751.  
  1752.     set(Windows[WID_MIMEPREFS], MUIA_Window_Open, FALSE);
  1753.  
  1754.     DoMethod(Gadgets[GID_MIMETYPES_LIST_PREFS], MUIM_List_Clear);
  1755.  
  1756.     RebuildMIMETypes();
  1757.  
  1758.     // Update the MIME Prefs list gadget
  1759.  
  1760.     DoMethod(Gadgets[GID_MIMETYPES_LIST_PREFS], MUIM_List_Insert, MIMETypes, -1, MUIV_List_Insert_Bottom);
  1761.  
  1762.     // Update the cycle gadgets
  1763.  
  1764.     if (DoMethod(Gadgets[GID_TYPE_GROUP_P1], MUIM_Group_InitChange))
  1765.     {
  1766.         DoMethod(Gadgets[GID_TYPE_GROUP_P1], OM_REMMEMBER, Gadgets[GID_TYPE_CYCLE_P1]);
  1767.         MUI_DisposeObject(Gadgets[GID_TYPE_CYCLE_P1]);
  1768.  
  1769.         DoMethod(Gadgets[GID_TYPE_GROUP_P1], OM_ADDMEMBER, Gadgets[GID_TYPE_CYCLE_P1] = CycleObject, MUIA_Cycle_Entries, MIMETypes, End);
  1770.  
  1771.         DoMethod(Gadgets[GID_TYPE_GROUP_P1], MUIM_Group_ExitChange);
  1772.     } /* if */
  1773.  
  1774.     if (DoMethod(Gadgets[GID_TYPE_GROUP_P3], MUIM_Group_InitChange))
  1775.     {
  1776.         DoMethod(Gadgets[GID_TYPE_GROUP_P3], OM_REMMEMBER, Gadgets[GID_TYPE_CYCLE_P3]);
  1777.         MUI_DisposeObject(Gadgets[GID_TYPE_CYCLE_P3]);
  1778.  
  1779.         DoMethod(Gadgets[GID_TYPE_GROUP_P3], OM_ADDMEMBER, Gadgets[GID_TYPE_CYCLE_P3] = CycleObject, MUIA_Cycle_Entries, MIMETypes, End);
  1780.  
  1781.         DoMethod(Gadgets[GID_TYPE_GROUP_P3], MUIM_Group_ExitChange);
  1782.     } /* if */
  1783.  
  1784.     if (DoMethod(Gadgets[GID_TYPE_GROUP_P4], MUIM_Group_InitChange))
  1785.     {
  1786.         DoMethod(Gadgets[GID_TYPE_GROUP_P4], OM_REMMEMBER, Gadgets[GID_TYPE_CYCLE_P4]);
  1787.         MUI_DisposeObject(Gadgets[GID_TYPE_CYCLE_P4]);
  1788.  
  1789.         DoMethod(Gadgets[GID_TYPE_GROUP_P4], OM_ADDMEMBER, Gadgets[GID_TYPE_CYCLE_P4] = CycleObject, MUIA_Cycle_Entries, MIMETypes, End);
  1790.  
  1791.         DoMethod(Gadgets[GID_TYPE_GROUP_P4], MUIM_Group_ExitChange);
  1792.     } /* if */
  1793.  
  1794.     // Save the prefs to ENV:MPackMUI.prefs
  1795.  
  1796.     SavePrefs("ENV:MPackMUI.prefs");
  1797.  
  1798.     // Wake up the main window
  1799.  
  1800.     set(Windows[WID_MAIN], MUIA_Window_Sleep, FALSE);
  1801.  
  1802.     return(0);
  1803. } /* PrefsUseButtonFunc() */
  1804.  
  1805. // --------------------------------------------------------------------------------------------------------------
  1806.  
  1807. __saveds LONG PrefsCancelButtonFunc(register __a0 struct Hook *hook, register __a2 APTR obj, register __a1 APTR param)
  1808. {
  1809.     // MIME Prefs Window: Cancel Button Gadget
  1810.  
  1811.     // Revert to old preferences
  1812.  
  1813.     // Close the window, clear the list and insert all entries from the MIME types array
  1814.  
  1815.     set(Windows[WID_MIMEPREFS], MUIA_Window_Open, FALSE);
  1816.  
  1817.     DoMethod(Gadgets[GID_MIMETYPES_LIST_PREFS], MUIM_List_Clear);
  1818.     DoMethod(Gadgets[GID_MIMETYPES_LIST_PREFS], MUIM_List_Insert, MIMETypes, -1, MUIV_List_Insert_Bottom);
  1819.  
  1820.     // Rebuild the MIME types list from the MIME types array
  1821.  
  1822.     RebuildMIMEList();
  1823.  
  1824.     // Wake up the main window
  1825.  
  1826.     set(Windows[WID_MAIN], MUIA_Window_Sleep, FALSE);
  1827.  
  1828.     return(0);
  1829. } /* PrefsCancelButtonFunc() */
  1830.  
  1831. // --------------------------------------------------------------------------------------------------------------
  1832.  
  1833. // Hooks
  1834.  
  1835. struct Hook MenuAboutHook = { {NULL, NULL}, (HOOKFUNC)MenuAboutFunc, NULL, NULL };
  1836. struct Hook MenuMIMEPrefsHook = { {NULL, NULL}, (HOOKFUNC)MenuMIMEPrefsFunc, NULL, NULL };
  1837. struct Hook MenuResetPrefsHook = { {NULL, NULL}, (HOOKFUNC)MenuResetPrefsFunc, NULL, NULL };
  1838. struct Hook MenuLastSavedPrefsHook = { {NULL, NULL}, (HOOKFUNC)MenuLastSavedPrefsFunc, NULL, NULL };
  1839. struct Hook MenuRestorePrefsHook = { {NULL, NULL}, (HOOKFUNC)MenuRestorePrefsFunc, NULL, NULL };
  1840. struct Hook MenuImportAwebPrefsHook = { {NULL, NULL}, (HOOKFUNC)MenuImportAwebPrefsFunc, NULL, NULL };
  1841. struct Hook MenuImportVoyagerPrefsHook = { {NULL, NULL}, (HOOKFUNC)MenuImportVoyagerPrefsFunc, NULL, NULL };
  1842. struct Hook Page1InputPopHook = { {NULL, NULL}, (HOOKFUNC)Page1InputPopFunc, NULL, NULL };
  1843. struct Hook Page1OutputPopHook = { {NULL, NULL}, (HOOKFUNC)Page1OutputPopFunc, NULL, NULL };
  1844. struct Hook Page1DescPopHook = { {NULL, NULL}, (HOOKFUNC)Page1DescPopFunc, NULL, NULL };
  1845. struct Hook Page1DescCheckHook = { {NULL, NULL}, (HOOKFUNC)Page1DescCheckFunc, NULL, NULL };
  1846. struct Hook Page1MaxCheckHook = { {NULL, NULL}, (HOOKFUNC)Page1MaxCheckFunc, NULL, NULL };
  1847. struct Hook Page1EncodeButtonHook = { {NULL, NULL}, (HOOKFUNC)Page1EncodeButtonFunc, NULL, NULL };
  1848. struct Hook Page2InputPopHook = { {NULL, NULL}, (HOOKFUNC)Page2InputPopFunc, NULL, NULL };
  1849. struct Hook Page2OutputPopHook = { {NULL, NULL}, (HOOKFUNC)Page2OutputPopFunc, NULL, NULL };
  1850. struct Hook Page2DecodeButtonHook = { {NULL, NULL}, (HOOKFUNC)Page2DecodeButtonFunc, NULL, NULL };
  1851. struct Hook Page3InputPopHook = { {NULL, NULL}, (HOOKFUNC)Page3InputPopFunc, NULL, NULL };
  1852. struct Hook Page3DescPopHook = { {NULL, NULL}, (HOOKFUNC)Page3DescPopFunc, NULL, NULL };
  1853. struct Hook Page3DescCheckHook = { {NULL, NULL}, (HOOKFUNC)Page3DescCheckFunc, NULL, NULL };
  1854. struct Hook Page3MaxCheckHook = { {NULL, NULL}, (HOOKFUNC)Page3MaxCheckFunc, NULL, NULL };
  1855. struct Hook Page3EncodeButtonHook = { {NULL, NULL}, (HOOKFUNC)Page3EncodeButtonFunc, NULL, NULL };
  1856. struct Hook Page4InputPopHook = { {NULL, NULL}, (HOOKFUNC)Page4InputPopFunc, NULL, NULL };
  1857. struct Hook Page4DescPopHook = { {NULL, NULL}, (HOOKFUNC)Page4DescPopFunc, NULL, NULL };
  1858. struct Hook Page4DescCheckHook = { {NULL, NULL}, (HOOKFUNC)Page4DescCheckFunc, NULL, NULL };
  1859. struct Hook Page4MaxCheckHook = { {NULL, NULL}, (HOOKFUNC)Page4MaxCheckFunc, NULL, NULL };
  1860. struct Hook Page4EncodeButtonHook = { {NULL, NULL}, (HOOKFUNC)Page4EncodeButtonFunc, NULL, NULL };
  1861. struct Hook PrefsMIMEListHook = { {NULL, NULL}, (HOOKFUNC)PrefsMIMEListFunc, NULL, NULL };
  1862. struct Hook PrefsMIMEUpdateHook = { {NULL, NULL}, (HOOKFUNC)PrefsMIMEUpdateFunc, NULL, NULL };
  1863. struct Hook PrefsAddButtonHook = { {NULL, NULL}, (HOOKFUNC)PrefsAddButtonFunc, NULL, NULL };
  1864. struct Hook PrefsRemoveButtonHook = { {NULL, NULL}, (HOOKFUNC)PrefsRemoveButtonFunc, NULL, NULL };
  1865. struct Hook PrefsCopyButtonHook = { {NULL, NULL}, (HOOKFUNC)PrefsCopyButtonFunc, NULL, NULL };
  1866. struct Hook PrefsSortButtonHook = { {NULL, NULL}, (HOOKFUNC)PrefsSortButtonFunc, NULL, NULL };
  1867. struct Hook PrefsSaveButtonHook = { {NULL, NULL}, (HOOKFUNC)PrefsSaveButtonFunc, NULL, NULL };
  1868. struct Hook PrefsUseButtonHook = { {NULL, NULL}, (HOOKFUNC)PrefsUseButtonFunc, NULL, NULL };
  1869. struct Hook PrefsCancelButtonHook = { {NULL, NULL}, (HOOKFUNC)PrefsCancelButtonFunc, NULL, NULL };
  1870.  
  1871. // --------------------------------------------------------------------------------------------------------------
  1872.  
  1873. // End Of Text
  1874.